public class LeetCode_7 {
   /* 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
    如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。
    假设环境不允许存储 64 位整数（有符号或无符号）。
    示例 1：
    输入：x = 123
    输出：321
    示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0
    */
    public int reverse(int x){
        int reverse = 0;
        while(x!=0){
            int pop=0;
            pop=x%10;
            x/=10;
            if(reverse>Integer.MAX_VALUE/10 || (reverse==Integer.MAX_VALUE/10 && pop>7)) return 0;
            if (reverse<Integer.MIN_VALUE/10 || (reverse==Integer.MIN_VALUE/10 && pop<8)) return 0;
            reverse = reverse*10+pop;
        }
        return reverse;
    }
 /*  public int reverse(int x) {
       int reversed = 0;
       //reversed 逆转

       while (x != 0) {
           int pop = x % 10; // 获取x的最低位
           x /= 10; // 移除x的最低位

           // 检查反转后的结果是否会溢出
           if (reversed > Integer.MAX_VALUE/10 || (reversed == Integer.MAX_VALUE / 10 && pop > 7)) return 0; // 溢出，返回0

          *//* 如果reversed已经大于Integer.MAX_VALUE / 10，那么乘以10后肯定会溢出，无论pop是多少。
           但是，如果reversed恰好等于Integer.MAX_VALUE / 10，我们还需要检查pop。
           因为Integer.MAX_VALUE的个位数是7（即2,147,483,647），所以如果pop大于7，那么加上pop后就会溢出。*//*
           if (reversed < Integer.MIN_VALUE/10 || (reversed == Integer.MIN_VALUE / 10 && pop < -8)) return 0; // 溢出，返回0
          *//* 如果reversed已经小于Integer.MIN_VALUE / 10，那么乘以10后肯定会溢出到int类型的最小值以下，
          无论pop是多少（因为我们是向下溢出，所以pop的加入只会使情况更糟）。
           但是，如果reversed恰好等于Integer.MIN_VALUE / 10，
           我们还需要检查pop。因为Integer.MIN_VALUE的个位数（如果考虑其绝对值）是8（即-2,147,483,648），
           注意这里是负的，所以实际上我们是在检查pop是否小于-8（即是否是一个比-8还小的负数）。
           如果pop小于-8，那么加上pop后就会溢出到int类型的最小值以下。*//*

           reversed = reversed * 10 + pop; // 反转
       }

       return reversed;
   }
*/
    public static void main(String[] args) {
        LeetCode_7 leetcode = new LeetCode_7();
        System.out.println(leetcode.reverse(1235));
    }
}
